home *** CD-ROM | disk | FTP | other *** search
/ Revista do CD-ROM 124 / cd-rom 124.iso / edu / tuxmath / tuxmathscrabble / tuxmathscrabble.exe / pygame / sprite.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-11-16  |  13.9 KB  |  473 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.2)
  3.  
  4.  
  5. class Sprite:
  6.     
  7.     def __init__(self, group = ()):
  8.         self._Sprite__g = { }
  9.         self.add(group)
  10.  
  11.     
  12.     def add(self, group):
  13.         has = self._Sprite__g.has_key
  14.         if hasattr(group, '_spritegroup'):
  15.             if not has(group):
  16.                 group.add_internal(self)
  17.                 self._Sprite__g[group] = 0
  18.             
  19.         else:
  20.             groups = group
  21.             for group in groups:
  22.                 if not has(group):
  23.                     group.add_internal(self)
  24.                     self._Sprite__g[group] = 0
  25.                 
  26.             
  27.  
  28.     
  29.     def remove(self, group):
  30.         has = self._Sprite__g.has_key
  31.         if hasattr(group, '_spritegroup'):
  32.             if has(group):
  33.                 group.remove_internal(self)
  34.                 del self._Sprite__g[group]
  35.             
  36.         else:
  37.             for g in group:
  38.                 if has(g):
  39.                     g.remove_internal(self)
  40.                     del self._Sprite__g[group]
  41.                 
  42.             
  43.  
  44.     
  45.     def add_internal(self, group):
  46.         self._Sprite__g[group] = 0
  47.  
  48.     
  49.     def remove_internal(self, group):
  50.         del self._Sprite__g[group]
  51.  
  52.     
  53.     def update(self, *args):
  54.         pass
  55.  
  56.     
  57.     def kill(self):
  58.         for c in self._Sprite__g.keys():
  59.             c.remove_internal(self)
  60.         
  61.         self._Sprite__g.clear()
  62.  
  63.     
  64.     def groups(self):
  65.         return self._Sprite__g.keys()
  66.  
  67.     
  68.     def alive(self):
  69.         return len(self._Sprite__g)
  70.  
  71.     
  72.     def __repr__(self):
  73.         return '<%s sprite(in %d groups)>' % (self.__class__.__name__, len(self._Sprite__g))
  74.  
  75.  
  76.  
  77. class Group:
  78.     _spritegroup = 1
  79.     
  80.     def __init__(self, sprite = ()):
  81.         self.spritedict = { }
  82.         if sprite:
  83.             self.add(sprite)
  84.         
  85.  
  86.     
  87.     def copy(self):
  88.         return self.__class__(self.spritedict.keys())
  89.  
  90.     
  91.     def sprites(self):
  92.         return self.spritedict.keys()
  93.  
  94.     
  95.     def add(self, sprite):
  96.         has = self.spritedict.has_key
  97.         if hasattr(sprite, '_spritegroup'):
  98.             for sprite in sprite.sprites():
  99.                 if not has(sprite):
  100.                     self.spritedict[sprite] = 0
  101.                     sprite.add_internal(self)
  102.                 
  103.             
  104.         else:
  105.             
  106.             try:
  107.                 len(sprite)
  108.             except (TypeError, AttributeError):
  109.                 if not has(sprite):
  110.                     self.spritedict[sprite] = 0
  111.                     sprite.add_internal(self)
  112.                 
  113.             except:
  114.                 not has(sprite)
  115.  
  116.             for sprite in sprite:
  117.                 if not has(sprite):
  118.                     self.spritedict[sprite] = 0
  119.                     sprite.add_internal(self)
  120.                 
  121.             
  122.  
  123.     
  124.     def remove(self, sprite):
  125.         has = self.spritedict.has_key
  126.         if hasattr(sprite, '_spritegroup'):
  127.             for sprite in sprite.sprites():
  128.                 if has(sprite):
  129.                     self.remove_internal(sprite)
  130.                     sprite.remove_internal(self)
  131.                 
  132.             
  133.         else:
  134.             
  135.             try:
  136.                 len(sprite)
  137.             except (TypeError, AttributeError):
  138.                 if has(sprite):
  139.                     self.remove_internal(sprite)
  140.                     sprite.remove_internal(self)
  141.                 
  142.             except:
  143.                 has(sprite)
  144.  
  145.             for sprite in sprite:
  146.                 if has(sprite):
  147.                     self.remove_internal(sprite)
  148.                     sprite.remove_internal(self)
  149.                 
  150.             
  151.  
  152.     
  153.     def add_internal(self, sprite):
  154.         self.spritedict[sprite] = 0
  155.  
  156.     
  157.     def remove_internal(self, sprite):
  158.         del self.spritedict[sprite]
  159.  
  160.     
  161.     def has(self, sprite):
  162.         has = self.spritedict.has_key
  163.         if hasattr(sprite, '_spritegroup'):
  164.             for sprite in sprite.sprites():
  165.                 if not has(sprite):
  166.                     return 0
  167.                 
  168.             
  169.         else:
  170.             
  171.             try:
  172.                 len(sprite)
  173.             except (TypeError, AttributeError):
  174.                 return has(sprite)
  175.  
  176.             for sprite in sprite:
  177.                 if not has(sprite):
  178.                     return 0
  179.                 
  180.             
  181.         return 1
  182.         if hasattr(sprite, '_spritegroup'):
  183.             return sprite in has(sprite)
  184.         
  185.         sprites = sprite
  186.         for sprite in sprites:
  187.             if not has(sprite):
  188.                 return 0
  189.             
  190.         
  191.         return 1
  192.  
  193.     
  194.     def empty(self):
  195.         for s in self.spritedict.keys():
  196.             self.remove_internal(s)
  197.             s.remove_internal(self)
  198.         
  199.         self.spritedict.clear()
  200.  
  201.     
  202.     def update(self, *args):
  203.         if args:
  204.             a = apply
  205.             for s in self.spritedict.keys():
  206.                 a(s.update, args)
  207.             
  208.         else:
  209.             for s in self.spritedict.keys():
  210.                 s.update()
  211.             
  212.  
  213.     
  214.     def __nonzero__(self):
  215.         return len(self.spritedict)
  216.  
  217.     
  218.     def __len__(self):
  219.         return len(self.spritedict)
  220.  
  221.     
  222.     def __repr__(self):
  223.         return '<%s(%d sprites)>' % (self.__class__.__name__, len(self))
  224.  
  225.  
  226.  
  227. class GroupSingle:
  228.     _spritegroup = 1
  229.     
  230.     def __init__(self, sprite = ()):
  231.         self.sprite = 0
  232.         self.add(sprite)
  233.  
  234.     
  235.     def copy(self):
  236.         if self.sprite is not 0:
  237.             return GroupSingle(self.sprite)
  238.         
  239.         return GroupSingle()
  240.  
  241.     
  242.     def sprites(self):
  243.         if self.sprite is not 0:
  244.             return [
  245.                 self.sprite]
  246.         
  247.         return []
  248.  
  249.     
  250.     def add(self, sprite):
  251.         if hasattr(sprite, '_spritegroup'):
  252.             for sprite in sprite.sprites():
  253.                 pass
  254.             
  255.         else:
  256.             
  257.             try:
  258.                 if not len(sprite):
  259.                     return None
  260.                 
  261.                 sprite = sprite[-1]
  262.             except (TypeError, AttributeError):
  263.                 pass
  264.  
  265.         if sprite is not self.sprite:
  266.             self.add_internal(sprite)
  267.             sprite.add_internal(self)
  268.         
  269.  
  270.     
  271.     def remove(self, sprite):
  272.         if hasattr(sprite, '_spritegroup'):
  273.             for sprite in sprite.sprites():
  274.                 if self.sprite is sprite:
  275.                     self.sprite = 0
  276.                     sprite.remove_internal(self)
  277.                     break
  278.                 
  279.             
  280.         else:
  281.             
  282.             try:
  283.                 if not len(sprite):
  284.                     return None
  285.             except (TypeError, AttributeError):
  286.                 if self.sprite is sprite:
  287.                     self.sprite = 0
  288.                     sprite.remove_internal(self)
  289.                 
  290.             except:
  291.                 self.sprite is sprite
  292.  
  293.             for sprite in sprite:
  294.                 if self.sprite is sprite:
  295.                     self.sprite = 0
  296.                     sprite.remove_internal(self)
  297.                     break
  298.                 
  299.             
  300.  
  301.     
  302.     def add_internal(self, sprite):
  303.         if self.sprite is not 0:
  304.             self.sprite.remove_internal(self)
  305.         
  306.         self.sprite = sprite
  307.  
  308.     
  309.     def remove_internal(self, sprite):
  310.         self.sprite = 0
  311.  
  312.     
  313.     def has(self, sprite):
  314.         return self.sprite is sprite
  315.  
  316.     
  317.     def empty(self):
  318.         if self.sprite is not 0:
  319.             self.sprite.remove_internal(self)
  320.             self.sprite = 0
  321.         
  322.  
  323.     
  324.     def update(self, *args):
  325.         if self.sprite:
  326.             apply(self.sprite.update(args))
  327.         
  328.  
  329.     
  330.     def __nonzero__(self):
  331.         return self.sprite is not 0
  332.  
  333.     
  334.     def __len__(self):
  335.         return self.sprite is not 0
  336.  
  337.     
  338.     def __repr__(self):
  339.         return '<%s(%d sprites)>' % (self.__class__.__name__, len(self))
  340.  
  341.  
  342.  
  343. class RenderPlain(Group):
  344.     
  345.     def draw(self, surface):
  346.         spritedict = self.spritedict
  347.         surface_blit = surface.blit
  348.         for s in spritedict.keys():
  349.             surface_blit(s.image, s.rect)
  350.         
  351.  
  352.  
  353.  
  354. class RenderClear(Group):
  355.     
  356.     def __init__(self, sprite = ()):
  357.         Group.__init__(self, sprite)
  358.         self.lostsprites = []
  359.  
  360.     
  361.     def remove_internal(self, sprite):
  362.         r = self.spritedict[sprite]
  363.         if r is not 0:
  364.             self.lostsprites.append(r)
  365.         
  366.         del self.spritedict[sprite]
  367.  
  368.     
  369.     def draw(self, surface):
  370.         spritedict = self.spritedict
  371.         surface_blit = surface.blit
  372.         for s in spritedict.keys():
  373.             spritedict[s] = surface_blit(s.image, s.rect)
  374.         
  375.         self.lostsprites = []
  376.  
  377.     
  378.     def clear(self, surface, bgd):
  379.         if callable(bgd):
  380.             for r in self.lostsprites:
  381.                 bgd(surface, r)
  382.             
  383.             for r in self.spritedict.values():
  384.                 if r is not 0:
  385.                     bgd(surface, r)
  386.                 
  387.             
  388.         else:
  389.             surface_blit = surface.blit
  390.             for r in self.lostsprites:
  391.                 surface_blit(bgd, r, r)
  392.             
  393.             for r in self.spritedict.values():
  394.                 if r is not 0:
  395.                     surface_blit(bgd, r, r)
  396.                 
  397.             
  398.  
  399.  
  400.  
  401. class RenderUpdates(RenderClear):
  402.     
  403.     def draw(self, surface):
  404.         spritedict = self.spritedict
  405.         surface_blit = surface.blit
  406.         dirty = self.lostsprites
  407.         self.lostsprites = []
  408.         dirty_append = dirty.append
  409.         for s, r in spritedict.items():
  410.             newrect = surface_blit(s.image, s.rect)
  411.             if r is 0:
  412.                 dirty_append(newrect)
  413.             elif newrect.colliderect(r):
  414.                 dirty_append(newrect.union(r))
  415.             else:
  416.                 dirty_append(newrect)
  417.                 dirty_append(r)
  418.             spritedict[s] = newrect
  419.         
  420.         return dirty
  421.  
  422.  
  423.  
  424. def spritecollide(sprite, group, dokill):
  425.     crashed = []
  426.     spritecollide = sprite.rect.colliderect
  427.     if dokill:
  428.         for s in group.sprites():
  429.             if spritecollide(s.rect):
  430.                 s.kill()
  431.                 crashed.append(s)
  432.             
  433.         
  434.     else:
  435.         for s in group.sprites():
  436.             if spritecollide(s.rect):
  437.                 crashed.append(s)
  438.             
  439.         
  440.     return crashed
  441.  
  442.  
  443. def groupcollide(groupa, groupb, dokilla, dokillb):
  444.     crashed = { }
  445.     SC = spritecollide
  446.     if dokilla:
  447.         for s in groupa.sprites():
  448.             c = SC(s, groupb, dokillb)
  449.             if c:
  450.                 crashed[s] = c
  451.                 s.kill()
  452.             
  453.         
  454.     else:
  455.         for s in groupa.sprites():
  456.             c = SC(s, groupb, dokillb)
  457.             if c:
  458.                 crashed[s] = c
  459.             
  460.         
  461.     return crashed
  462.  
  463.  
  464. def spritecollideany(sprite, group):
  465.     spritecollide = sprite.rect.colliderect
  466.     for s in group.sprites():
  467.         if spritecollide(s.rect):
  468.             return s
  469.         
  470.     
  471.     return None
  472.  
  473.